// 内容脚本 - 处理页面级别的会话隔离
(function() {
  'use strict';

  let currentSessionId = null;
  let sessionConfig = null;

  // 检查扩展上下文是否有效
  function isExtensionContextValid() {
    try {
      return !!(chrome.runtime && chrome.runtime.id);
    } catch (error) {
      return false;
    }
  }

  // 生成页面的一致会话ID
  function generatePageSessionId() {
    const hostname = window.location.hostname;
    const pathname = window.location.pathname;
    return 'page_' + hostname + '_' + btoa(pathname).replace(/[^a-zA-Z0-9]/g, '').substring(0, 8);
  }

  // 安全地发送消息到background script
  async function safeSendMessage(message) {
    if (!isExtensionContextValid()) {
      console.warn('SessionBox: 扩展上下文无效，无法发送消息');
      return null;
    }

    try {
      return await chrome.runtime.sendMessage(message);
    } catch (error) {
      if (error.message && error.message.includes('Extension context invalidated')) {
        console.warn('SessionBox: 扩展上下文已失效');
      } else {
        console.error('SessionBox: 发送消息失败:', error);
      }
      return null;
    }
  }

  // 初始化内容脚本
  async function init() {
    try {
      console.log('SessionBox: 开始初始化内容脚本');
      
      // 立即注入脚本，不等待会话信息
      injectScript();
      
      // 获取当前标签页的会话信息
      const response = await safeSendMessage({
        action: 'getCurrentSession'
      });
      
      if (response && response.success && response.session) {
        currentSessionId = response.session.id;
        sessionConfig = response.session;
        
        console.log('SessionBox: 获取到会话信息:', sessionConfig);
        
        // 初始化注入脚本的会话数据
        await initializeInjectedScript();
        
        // 应用会话配置
        await applySessionConfig();
        
        console.log('SessionBox: 会话内容脚本已初始化，会话ID:', currentSessionId);
      } else {
        console.log('SessionBox: 没有找到会话信息，初始化空会话环境');
        
        // 即使没有会话信息，也要初始化注入脚本，确保存储API被重写
        currentSessionId = 'default';
        sessionConfig = null;
        
        // 初始化空的会话数据
        await initializeInjectedScript();
      }
    } catch (error) {
      console.error('SessionBox: 初始化内容脚本失败:', error);
    }
  }

  // 应用会话配置
  async function applySessionConfig() {
    if (!sessionConfig) return;

    // 应用指纹保护
    if (sessionConfig.fingerprintProtection) {
      await applyFingerprintProtection();
    }

    // 应用自定义User Agent
    if (sessionConfig.userAgent) {
      applyUserAgent(sessionConfig.userAgent);
    }

    // 更新页面标题指示器
    if (sessionConfig.fingerprintConfig && sessionConfig.fingerprintConfig.showIndicator) {
      updatePageIndicator();
    }
  }

  // 应用指纹保护
  async function applyFingerprintProtection() {
    if (!sessionConfig.fingerprintConfig) return;

    const config = sessionConfig.fingerprintConfig;

    // Canvas保护
    if (config.protectCanvas) {
      protectCanvas();
    }

    // WebGL保护
    if (config.protectWebGL) {
      protectWebGL();
    }

    // Audio保护
    if (config.protectAudio) {
      protectAudioContext();
    }

    // WebRTC保护
    if (config.blockWebRTC) {
      blockWebRTC();
    }
  }

  // Canvas指纹保护
  function protectCanvas() {
    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
    const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;

    HTMLCanvasElement.prototype.toDataURL = function(...args) {
      // 添加随机噪声
      const ctx = this.getContext('2d');
      if (ctx) {
        addCanvasNoise(ctx, this.width, this.height);
      }
      return originalToDataURL.apply(this, args);
    };

    CanvasRenderingContext2D.prototype.getImageData = function(...args) {
      const imageData = originalGetImageData.apply(this, args);
      // 添加轻微的噪声
      addImageDataNoise(imageData);
      return imageData;
    };
  }

  // 添加Canvas噪声
  function addCanvasNoise(ctx, width, height) {
    const imageData = ctx.getImageData(0, 0, width, height);
    const data = imageData.data;
    
    for (let i = 0; i < data.length; i += 4) {
      // 添加轻微的随机噪声
      const noise = Math.random() * 2 - 1;
      data[i] = Math.min(255, Math.max(0, data[i] + noise));     // Red
      data[i + 1] = Math.min(255, Math.max(0, data[i + 1] + noise)); // Green
      data[i + 2] = Math.min(255, Math.max(0, data[i + 2] + noise)); // Blue
    }
    
    ctx.putImageData(imageData, 0, 0);
  }

  // 添加ImageData噪声
  function addImageDataNoise(imageData) {
    const data = imageData.data;
    for (let i = 0; i < data.length; i += 4) {
      const noise = Math.random() * 0.5 - 0.25;
      data[i] = Math.min(255, Math.max(0, data[i] + noise));
      data[i + 1] = Math.min(255, Math.max(0, data[i + 1] + noise));
      data[i + 2] = Math.min(255, Math.max(0, data[i + 2] + noise));
    }
  }

  // WebGL指纹保护
  function protectWebGL() {
    const originalGetParameter = WebGLRenderingContext.prototype.getParameter;
    
    WebGLRenderingContext.prototype.getParameter = function(parameter) {
      // 修改特定的WebGL参数
      switch (parameter) {
        case this.RENDERER:
          return 'Generic Renderer';
        case this.VENDOR:
          return 'Generic Vendor';
        case this.VERSION:
          return 'WebGL 1.0';
        case this.SHADING_LANGUAGE_VERSION:
          return 'WebGL GLSL ES 1.0';
        default:
          return originalGetParameter.apply(this, arguments);
      }
    };

    // 也保护WebGL2
    if (window.WebGL2RenderingContext) {
      const originalGetParameter2 = WebGL2RenderingContext.prototype.getParameter;
      WebGL2RenderingContext.prototype.getParameter = function(parameter) {
        switch (parameter) {
          case this.RENDERER:
            return 'Generic Renderer';
          case this.VENDOR:
            return 'Generic Vendor';
          case this.VERSION:
            return 'WebGL 2.0';
          case this.SHADING_LANGUAGE_VERSION:
            return 'WebGL GLSL ES 3.0';
          default:
            return originalGetParameter2.apply(this, arguments);
        }
      };
    }
  }

  // Audio指纹保护
  function protectAudioContext() {
    const originalCreateAnalyser = AudioContext.prototype.createAnalyser;
    
    AudioContext.prototype.createAnalyser = function() {
      const analyser = originalCreateAnalyser.apply(this, arguments);
      const originalGetFloatFrequencyData = analyser.getFloatFrequencyData;
      
      analyser.getFloatFrequencyData = function(array) {
        originalGetFloatFrequencyData.apply(this, arguments);
        // 添加随机噪声
        for (let i = 0; i < array.length; i++) {
          array[i] += Math.random() * 0.001 - 0.0005;
        }
      };
      
      return analyser;
    };
  }

  // WebRTC保护
  function blockWebRTC() {
    // 阻止WebRTC IP泄露
    const originalCreateOffer = RTCPeerConnection.prototype.createOffer;
    const originalCreateAnswer = RTCPeerConnection.prototype.createAnswer;
    
    RTCPeerConnection.prototype.createOffer = function() {
      return Promise.reject(new Error('WebRTC 已被 SessionBox 阻止'));
    };
    
    RTCPeerConnection.prototype.createAnswer = function() {
      return Promise.reject(new Error('WebRTC 已被 SessionBox 阻止'));
    };
  }

  // 应用自定义User Agent
  function applyUserAgent(userAgent) {
    Object.defineProperty(navigator, 'userAgent', {
      get: () => userAgent,
      configurable: false
    });
  }

  // 注入脚本到页面
  function injectScript() {
    console.log('SessionBox: 开始注入脚本');
    
    // 直接使用外部脚本，确保代码正确性
    const script = document.createElement('script');
    script.src = chrome.runtime.getURL('content/injected.js');
    script.onload = function() {
      console.log('SessionBox: 注入脚本已加载');
      this.remove();
    };
    script.onerror = function() {
      console.error('SessionBox: 注入脚本加载失败');
    };
    
    // 在文档头部尽早插入
    (document.head || document.documentElement).appendChild(script);
  }

  // 与注入脚本通信
  function sendMessageToInjected(action, data) {
    window.postMessage({
      type: 'SESSIONBOX_TO_INJECTED',
      action: action,
      data: data
    }, '*');
  }

  // 监听来自注入脚本的消息
  window.addEventListener('message', (event) => {
    if (event.source !== window) return;
    
    if (event.data.type === 'SESSIONBOX_FROM_INJECTED') {
      const { action } = event.data;
      
      switch (action) {
        case 'INJECTED_READY':
          console.log('SessionBox: 注入脚本已准备好');
          initializeInjectedScript();
          break;
          
        case 'SAVE_STORAGE':
          console.log('SessionBox: 收到保存存储请求:', event.data.type, event.data.data);
          saveSessionStorageToBackground(event.data.type, event.data.data);
          break;
          
        case 'SAVE_COOKIES':
          console.log('SessionBox: 收到保存Cookie请求:', event.data.cookies);
          saveSessionCookieToBackground(event.data.cookies);
          break;
      }
    }
  });

  // 初始化注入脚本
  async function initializeInjectedScript() {
    console.log('SessionBox: 开始初始化注入脚本，会话ID:', currentSessionId);
    
    // 加载会话数据
    const storageData = await loadSessionStorageFromBackground();
    const cookieData = await loadSessionCookieFromBackground();
    
    console.log('SessionBox: 加载的存储数据:', storageData);
    console.log('SessionBox: 加载的Cookie数据:', cookieData);
    
    // 发送初始化数据到注入脚本
    sendMessageToInjected('INIT_SESSION', {
      sessionId: currentSessionId || 'default',
      sessionConfig: sessionConfig,
      storageData: storageData,
      cookieData: cookieData
    });
    
    console.log('SessionBox: 注入脚本初始化数据已发送');
  }
  
  // 保存会话存储到后台
  async function saveSessionStorageToBackground(type, data) {
    // 如果没有会话ID，为当前页面创建一个默认会话ID
    if (!currentSessionId || currentSessionId === 'default') {
      if (!currentSessionId) {
        currentSessionId = generatePageSessionId();
        console.log('SessionBox: 为当前页面创建默认会话ID:', currentSessionId);
      } else {
        console.log('SessionBox: 使用默认会话，数据将保存到默认会话中');
      }
    }
    
    try {
      await safeSendMessage({
        action: 'saveSessionStorage',
        sessionId: currentSessionId,
        type: type,
        data: data
      });
    } catch (error) {
      console.warn('SessionBox: 保存会话存储到后台失败:', error);
    }
  }
  
  // 从后台加载会话存储
  async function loadSessionStorageFromBackground() {
    // 如果没有会话ID，为当前页面创建一个默认会话ID
    if (!currentSessionId || currentSessionId === 'default') {
      if (!currentSessionId) {
        // 尝试从URL生成一致的会话ID，这样同一页面刷新后能找到相同的数据
        currentSessionId = generatePageSessionId();
        console.log('SessionBox: 为当前页面生成一致的会话ID:', currentSessionId);
      } else {
        console.log('SessionBox: 使用默认会话加载数据');
      }
    }
    
    try {
      const response = await safeSendMessage({
        action: 'getSessionStorage',
        sessionId: currentSessionId
      });
      
      if (response && response.success && response.data) {
        console.log('SessionBox: 从后台加载会话存储成功:', response.data);
        return response.data;
      }
    } catch (error) {
      console.warn('SessionBox: 从后台加载会话存储失败:', error);
    }
    
    return {
      localStorage: {},
      sessionStorage: {}
    };
  }

  // 保存会话Cookie到后台
  async function saveSessionCookieToBackground(cookies) {
    // 如果没有会话ID，为当前页面创建一个默认会话ID
    if (!currentSessionId || currentSessionId === 'default') {
      if (!currentSessionId) {
        currentSessionId = generatePageSessionId();
        console.log('SessionBox: 为当前页面创建默认会话ID:', currentSessionId);
      } else {
        console.log('SessionBox: 使用默认会话，数据将保存到默认会话中');
      }
    }
    
    try {
      await safeSendMessage({
        action: 'saveSessionCookies',
        sessionId: currentSessionId,
        cookies: cookies
      });
    } catch (error) {
      console.warn('SessionBox: 保存会话Cookie到后台失败:', error);
    }
  }
  
  // 从后台加载会话Cookie
  async function loadSessionCookieFromBackground() {
    // 如果没有会话ID，为当前页面创建一个默认会话ID
    if (!currentSessionId || currentSessionId === 'default') {
      if (!currentSessionId) {
        currentSessionId = generatePageSessionId();
        console.log('SessionBox: 为当前页面生成一致的会话ID:', currentSessionId);
      } else {
        console.log('SessionBox: 使用默认会话加载Cookie');
      }
    }
    
    try {
      const response = await safeSendMessage({
        action: 'getSessionCookies',
        sessionId: currentSessionId
      });
      
      if (response && response.success && response.cookies) {
        console.log('SessionBox: 从后台加载会话Cookie成功:', response.cookies);
        return response.cookies;
      }
    } catch (error) {
      console.warn('SessionBox: 从后台加载会话Cookie失败:', error);
    }
    
    return {};
  }

  // 更新页面指示器
  function updatePageIndicator() {
    if (!sessionConfig || !sessionConfig.fingerprintConfig || !sessionConfig.fingerprintConfig.showIndicator) return;

    // 在页面标题前添加会话指示器
    const originalTitle = document.title;
    const indicator = `[${sessionConfig.name}] `;
    
    if (!originalTitle.startsWith(indicator)) {
      document.title = indicator + originalTitle;
    }

    // 添加视觉指示器
    addVisualIndicator();
  }

  // 添加视觉指示器
  function addVisualIndicator() {
    try {
      if (!document.body) {
        // 如果DOM未准备好，稍后再试
        setTimeout(addVisualIndicator, 100);
        return;
      }

      // 移除已存在的指示器
      const existingIndicator = document.getElementById('sessionbox-indicator');
      if (existingIndicator) {
        existingIndicator.remove();
      }

      const indicator = document.createElement('div');
      indicator.id = 'sessionbox-indicator';
      indicator.style.cssText = `
        position: fixed;
        top: 0;
        right: 0;
        width: 4px;
        height: 100vh;
        background-color: ${sessionConfig.color};
        z-index: 2147483647;
        pointer-events: none;
      `;
      
      document.body.appendChild(indicator);
    } catch (error) {
      console.warn('SessionBox: 添加视觉指示器失败:', error);
    }
  }

  // 监听会话切换
  if (isExtensionContextValid()) {
    try {
      chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
        try {
          if (message.action === 'sessionSwitched') {
            currentSessionId = message.sessionId;
            sessionConfig = message.session;
            
            // 重新应用会话配置
            applySessionConfig().catch(error => {
              console.warn('SessionBox: 应用会话配置失败:', error);
            });
            
            sendResponse({ success: true });
          }
        } catch (error) {
          console.warn('SessionBox: 处理消息失败:', error);
          sendResponse({ success: false, error: error.message });
        }
        return true; // 保持消息通道开放
      });
    } catch (error) {
      console.warn('SessionBox: 无法设置消息监听器:', error);
    }
  }

  // 页面卸载时清理
  window.addEventListener('beforeunload', () => {
    // 使用同步方式尝试发送消息，忽略错误
    try {
      if (isExtensionContextValid()) {
        safeSendMessage({
          action: 'pageUnloading',
          sessionId: currentSessionId
        }).catch(() => {
          // 忽略所有错误，页面卸载时这是正常的
        });
      }
    } catch (error) {
      // 忽略所有错误，页面卸载时这是正常的
    }
  });

  // 立即初始化，不等待DOM
  init().catch(error => {
    console.warn('SessionBox: 初始化失败:', error);
  });
})(); 